#include "struttura_dati.h"
#include <gtk/gtk.h>
#include "manip_mano.h"
#include <iostream>
#include <cstring>

using namespace std;
 
extern GtkBuilder *builder;

extern partita_t partita;

extern gioca_t gioca;

extern turno_t turno;


/** Funzione che setta la mano del giocatore.
 *  Se deve giocare il giocatore, setta a sensitive le carte.
 */
void setta_mano(){
	D1(cout<<"INIZIA DEBUG setta_mano"<<endl);
	if(gioca == giocatore){
		gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(builder,
						"carta1")),true);
		gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(builder,
						"carta2")),true);
		gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(builder,
						"carta3")),true);
		}

	else{
		gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(builder,
						"carta1")),false);
		gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(builder,
						"carta2")),false);
		gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(builder,
						"carta3")),false);
		}

	/* Parte riguardante solo nelle mani finali.
	 * Se le carte della mano hanno nome "torre.gif" allora non abilitare i
	 * rispettivi bottoni.
	 */		
	for(int i=0; i<3; i++){
		if(strcmp(partita.player1.mano[0].nome,"torre.gif")==0)
			gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(builder,
						"carta1")),false);
		if(strcmp(partita.player1.mano[1].nome,"torre.gif")==0)
			gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(builder,
						"carta2")),false);
		if(strcmp(partita.player1.mano[2].nome,"torre.gif")==0)
			gtk_widget_set_sensitive(GTK_WIDGET(gtk_builder_get_object(builder,
						"carta3")),false);
		}
	D1(cout<<"FINE DEBUG SETTA MANO"<<endl);
}

/** Funzione che ristabilisce il gioco : libera il campo e carica le carte
  * nella mano. g identifica il giocatore, se true allora si riferisce al 
  * giocatore, altrimenti al computer
  */
static void refresh_mano(int i, bool g){
	D1(cout<<"INIZIO DEBUG refresh_mano"<<endl);
	GtkImage *immagine;

	/* E' un controllo, per far sì che il refresh lo faccia solo quando il turno
	 * è ridiventato primo.
	 */	
	if(turno == primo){
		
		// se giocatore
		if(g==true){

			switch(i){
			  case 0:
						immagine=GTK_IMAGE(gtk_builder_get_object(builder, "0"));					
						gtk_image_set_from_file(immagine, partita.player1.mano[i].nome);
						gtk_widget_set_visible(GTK_WIDGET(gtk_builder_get_object(builder,
												 "0")), true);
						break;
			 case 1: 
						immagine=GTK_IMAGE(gtk_builder_get_object(builder, "1"));
						gtk_image_set_from_file(immagine, partita.player1.mano[i].nome);
						gtk_widget_set_visible(GTK_WIDGET(gtk_builder_get_object(builder,
												 "1")), true);
						break;
			 case 2: 
						immagine=GTK_IMAGE(gtk_builder_get_object(builder, "2"));
						gtk_image_set_from_file(immagine, partita.player1.mano[i].nome);
						gtk_widget_set_visible(GTK_WIDGET(gtk_builder_get_object(builder,
												 "2")), true);
						break;
			 default: 
						cout<<"ERRORE, IMPOSSIBILE!!"<<endl;
			 }
		}	
	
		else{
			// parte comune sia che sia o non sia definito ALTERNATIVE
			// deve creare la stinga con il nome dell' immagine, la utilizza dentro
			// ifdef e else
			char c[2];
			c[0]=i+3+'0';
			c[1]='\0';

			#ifdef ALTERNATIVE 
			switch(i){
			  case 0:  
						immagine=GTK_IMAGE(gtk_builder_get_object(builder, "3"));
						gtk_image_set_from_file(immagine, partita.player2.mano[i].nome);
						gtk_widget_set_visible(GTK_WIDGET(gtk_builder_get_object(builder,
												 "3")), true);
						break;
			  case 1:  
						immagine=GTK_IMAGE(gtk_builder_get_object(builder, "4"));
						gtk_image_set_from_file(immagine, partita.player2.mano[i].nome);
						gtk_widget_set_visible(GTK_WIDGET(gtk_builder_get_object(builder,
												 "4")), true);
						break;
  			  case 2:  
						immagine=GTK_IMAGE(gtk_builder_get_object(builder, "5"));
						gtk_image_set_from_file(immagine, partita.player2.mano[i].nome);
						gtk_widget_set_visible(GTK_WIDGET(gtk_builder_get_object(builder,
												 "5")), true);
						break;
			  default: 
						cout<<"ERRORE, IMPOSSIBILE!!"<<endl;
				}
			
			// se sono alla fine della partita
			if(partita.idx==40)
				gtk_image_set_from_file(GTK_IMAGE(gtk_builder_get_object(builder, c)),
						 "./torre.gif");

			#else			
			// se durante la partita, deve far riferimento a "retro.jpg"
			if(partita.idx<40){
				gtk_image_set_from_file(GTK_IMAGE(gtk_builder_get_object(builder, c)),
						 "./Carte/retro.jpg");
				}
			else{
				gtk_image_set_from_file(GTK_IMAGE(gtk_builder_get_object(builder, c)),
						 "./torre.gif");
				}

			gtk_widget_set_visible(GTK_WIDGET(gtk_builder_get_object(builder, c)),
						 true);

			#endif
			}
	}		// fine primo if
		
	/* Faccio un controllo sull'indice, per impedirgli di andare a puntare una
	 * cella fuori dall'array.
	 */	
	if(partita.idx<39)
		partita.idx++;
	D1(cout<<"FINE DEBUG REFRESH MANO"<<endl);
}

/** Funzione che carica la carta pescata dal giocatore alla posizione giusta
  */
static void pesca_giocatore(){
	D1(cout<<"INIZIO DEBUG pesca_giocatore"<<endl);
	for(int i=0; i<3; i++){
		// controlla quale carta era stata giocata, per caricare lì la nuova
		if(partita.player1.mano[i].selez == true){
			partita.player1.mano[i].val=partita.mazzo[partita.idx].val;
			strcpy(partita.player1.mano[i].nome, partita.mazzo[partita.idx].nome);

			/* in refresh c'è l'incremento dell'indice del mazzo,
			 * true è per identificare il giocatore */
			refresh_mano(i, true);
			partita.player1.mano[i].selez = false;
			}
		}
	D1(cout<<"FINE DEBUG PESCA GIOCATORE"<<endl);
}

/** Funzione che carica la carta pescata dal computer alla posizione giusta
  */
static void pesca_computer(){
	D1(cout<<"INIZIO DEBUG pesca_computer"<<endl);
	for(int i=0; i<3; i++){
		// controlla quale carta era stata giocata, per caricare lì la nuova
		if(partita.player2.mano[i].selez == true){
			partita.player2.mano[i].val=partita.mazzo[partita.idx].val;
			strcpy(partita.player2.mano[i].nome, partita.mazzo[partita.idx].nome);
			
			/* in refresh c'è l'incremento dell'indice del mazzo,
			 * false è per identificare il computer */
			refresh_mano(i, false);
			partita.player2.mano[i].selez = false;
			}
		}	
	D1(cout<<"FINE DEBUG PESCA COMPUTER"<<endl);
}

/** Funzione che genera la mano di gioco, caricando le carte dal mazzo
  * alle rispettive mani.
  * Funzione che funge anche da aggiornamento della mano durante il gioco.
  */
void carica_mano(){
	D1(cout<<"INIZIO DEBUG carica_mano"<<endl);
	/* utilizza l'indice 40 perchè è l'indice immediatamente successivo a quelli
      usati. Metto prima questo if, perchè in quello successivo mi cambierebbe 
		l'indice, e alla fine della partita entrerebbe in entrambi gli if.
		Entra in questo if, solo nelle ultime mani della partita, ovvero quando
		non bisogna più pescare.
	*/
	if(partita.idx==40){	
		D2(cout<<"entra nell' if ultime tre mani"<<endl);
		for(int i=0; i<3; i++){

			if(partita.player1.mano[i].selez == true){
				partita.player1.mano[i].val=-1;
				strcpy(partita.player1.mano[i].nome, "torre.gif");
				partita.player2.mano[i].esiste=false;					
				refresh_mano(i, true);
				partita.player1.mano[i].selez = false;
				}
			}

		for(int i=0; i<3; i++){

			if(partita.player2.mano[i].selez == true){

				partita.player2.mano[i].val=-1;
				strcpy(partita.player2.mano[i].nome, "torre.gif");
				partita.player2.mano[i].esiste=false;					
				refresh_mano(i, false);
				partita.player2.mano[i].selez = false;
				}
			}
		D2(cout<<"fine if ultime tre mani"<<endl);
		}
		
	/* in questo if entrerà solo una volta, cioè quando sono alla quart'ultima
		mano. Quindi il giocatore vincente della mano precedente pesca dal mazzo
 		l'ultima carta, mentre l'altro giocatore deve pescare la briscola girata. 
	*/
	if(partita.idx==39){
		D2(cout<<"entra nell'if della quart'ultima mano"<<endl);
		// caso in cui l'ultima mano sia stata vinta dal giocatore
		if(gioca==giocatore){

			// Il giocatore prende l'ultima carta coperta
			pesca_giocatore();

			// il pc deve prendere la briscola scoperta.
			// utilizza pesca_computer, ma per farlo adatta prima l'indice
			partita.idx=6;
			pesca_computer();
			partita.idx=40;

			//faccio scomparire la carta di briscola
			gtk_widget_set_visible(GTK_WIDGET(gtk_builder_get_object(builder,
						"image1")), false);
			}

		// caso in cui l'ultima mano sia stata vinta dal computer
		else{
			// il computer pesca l'ultima carta del mazzo
			pesca_computer();
			
			// il giocatore deve prendere la briscola scoperta.
			// utilizza pesca_giocatore, ma per farlo adatta prima l'indice 
			partita.idx=6;
			pesca_giocatore();
			partita.idx=40;
			
			//faccio scomparire la carta di briscola
			gtk_widget_set_visible(GTK_WIDGET(gtk_builder_get_object(builder,
						"image1")), false);
			}

		/* deve sparire l'immagine del mazzo, ma non il bottone, e deve far 
		 * comparire una labal con scritto fine turno
		 */

		//sparisce l'immagine del mazzo, ma non il bottone
		gtk_widget_set_visible(GTK_WIDGET(gtk_builder_get_object(builder,"mazz")),
					 false);
		//setto la label con scritto 'fine turno' a visible da programma
		gtk_widget_set_visible(GTK_WIDGET(gtk_builder_get_object(builder,"f")),
					 true);
		// tolgo la label delle carte mancanti, dato che sono finite
		gtk_widget_set_visible(GTK_WIDGET(gtk_builder_get_object(builder,
					"indice")), false);
		D2(cout<<"fine if della quart'ultima mano"<<endl);
		}

	/* If in cui si entra per tutto lo svolgimento della partita, tranne che nelle
	 * ultime quattro mani.
	 */
	if(partita.idx<39){
		D2(cout<<"entra nell'if di tutto il normale corso della partita"<<endl);
		if(gioca==giocatore){	
			
			pesca_giocatore();
			
			pesca_computer();
			}

		else{			
			
			pesca_computer();
			
			pesca_giocatore();
			}
		D2(cout<<"fine if di tutto il normale corso della partita"<<endl);
		}
	D1(cout<<"FINE DEBUG CARICA MANO"<<endl);
}

